home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / unixSyscall / RCS / id.c,v < prev    next >
Text File  |  1988-06-21  |  6KB  |  301 lines
  1. head     1.2;
  2. access   ;
  3. symbols  ;
  4. locks    ; strict;
  5. comment  @ * @;
  6.  
  7.  
  8. 1.2
  9. date     88.06.21.16.50.41;  author ouster;  state Exp;
  10. branches ;
  11. next     1.1;
  12.  
  13. 1.1
  14. date     88.06.19.14.31.31;  author ouster;  state Exp;
  15. branches ;
  16. next     ;
  17.  
  18.  
  19. desc
  20. @@
  21.  
  22.  
  23. 1.2
  24. log
  25. @Forgot to eliminate io.h usage.
  26. @
  27. text
  28. @/* 
  29.  * id.c --
  30.  *
  31.  *    Procedure to map from Unix *id system calls to Sprite.  Note that
  32.  *    procedures dealing with group ID's (as opposed to user ID's and
  33.  *    process ID's) are contained in groupId.c.
  34.  *
  35.  * Copyright (C) 1986 Regents of the University of California
  36.  * All rights reserved.
  37.  */
  38.  
  39. #ifndef lint
  40. static char rcsid[] = "$Header: id.c,v 1.1 88/06/19 14:31:31 ouster Exp $ SPRITE (Berkeley)";
  41. #endif not lint
  42.  
  43. #include <sprite.h>
  44. #include <proc.h>
  45.  
  46. #include "compatInt.h"
  47.  
  48.  
  49. /*
  50.  *----------------------------------------------------------------------
  51.  *
  52.  * getuid --
  53.  *
  54.  *    Procedure to map from Unix getuid system call to Sprite Proc_GetIDs.
  55.  *
  56.  * Results:
  57.  *    UNIX_ERROR is returned upon error, with the actual error code
  58.  *    stored in errno.  Upon success, the real user ID of the current
  59.  *    process is returned.
  60.  *
  61.  * Side effects:
  62.  *    None.
  63.  *
  64.  *----------------------------------------------------------------------
  65.  */
  66.  
  67. int
  68. getuid()
  69. {
  70.     ReturnStatus status;    /* result returned by Proc_GetIDs */
  71.     int userId;            /* real user ID of current process */
  72.  
  73.     status = Proc_GetIDs((Proc_PID *) NULL, (Proc_PID *) NULL,
  74.                  &userId, (Proc_PID *) NULL);
  75.     if (status != SUCCESS) {
  76.     errno = Compat_MapCode(status);
  77.     return(UNIX_ERROR);
  78.     } else {
  79.     return(userId);
  80.     }
  81. }
  82.  
  83.  
  84. /*
  85.  *----------------------------------------------------------------------
  86.  *
  87.  * geteuid --
  88.  *
  89.  *    Procedure to map from Unix geteuid system call to Sprite Proc_GetIDs.
  90.  *
  91.  * Results:
  92.  *    UNIX_ERROR is returned upon error, with the actual error code
  93.  *    stored in errno.  Upon success, the effective user ID of the current
  94.  *    process is returned.
  95.  *
  96.  * Side effects:
  97.  *    None.
  98.  *
  99.  *----------------------------------------------------------------------
  100.  */
  101.  
  102. int
  103. geteuid()
  104. {
  105.     ReturnStatus status;    /* result returned by Proc_GetIDs */
  106.     int userId;            /* effective user ID of current process */
  107.  
  108.     status = Proc_GetIDs((Proc_PID *) NULL, (Proc_PID *) NULL,
  109.             (Proc_PID *) NULL, &userId);
  110.     if (status != SUCCESS) {
  111.     errno = Compat_MapCode(status);
  112.     return(UNIX_ERROR);
  113.     } else {
  114.     return(userId);
  115.     }
  116. }
  117.  
  118.  
  119. /*
  120.  *----------------------------------------------------------------------
  121.  *
  122.  * getpid --
  123.  *
  124.  *    Procedure to map from Unix getpid system call to Sprite Proc_GetIDs.
  125.  *
  126.  * Results:
  127.  *    UNIX_ERROR is returned upon error, with the actual error code
  128.  *    stored in errno.  Upon success, the process ID of the current
  129.  *    process is returned.
  130.  *
  131.  * Side effects:
  132.  *    None.
  133.  *
  134.  *----------------------------------------------------------------------
  135.  */
  136.  
  137. int
  138. getpid()
  139. {
  140.     ReturnStatus status;    /* result returned by Proc_GetIDs */
  141.     int pid;            /* ID of current process */
  142.  
  143.     status = Proc_GetIDs(&pid, (Proc_PID *) NULL,
  144.              (Proc_PID *) NULL, (Proc_PID *) NULL);
  145.     if (status != SUCCESS) {
  146.     errno = Compat_MapCode(status);
  147.     return(UNIX_ERROR);
  148.     } else {
  149.     return(pid);
  150.     }
  151. }
  152.  
  153.  
  154. /*
  155.  *----------------------------------------------------------------------
  156.  *
  157.  * getppid --
  158.  *
  159.  *    Procedure to map from Unix getppid system call to Sprite Proc_GetIDs.
  160.  *
  161.  * Results:
  162.  *    UNIX_ERROR is returned upon error, with the actual error code
  163.  *    stored in errno.  Upon success, the ID of the parent of the current
  164.  *    process is returned.
  165.  *
  166.  * Side effects:
  167.  *    None.
  168.  *
  169.  *----------------------------------------------------------------------
  170.  */
  171.  
  172. int
  173. getppid()
  174. {
  175.     ReturnStatus status;    /* result returned by Proc_GetIDs */
  176.     int parentPid;        /* ID of parent of current process */
  177.  
  178.     status = Proc_GetIDs((Proc_PID *) NULL, &parentPid,
  179.             (Proc_PID *) NULL, (Proc_PID *) NULL);
  180.     if (status != SUCCESS) {
  181.     errno = Compat_MapCode(status);
  182.     return(UNIX_ERROR);
  183.     } else {
  184.     return(parentPid);
  185.     }
  186. }
  187.  
  188.  
  189. /*
  190.  *----------------------------------------------------------------------
  191.  *
  192.  * setreuid --
  193.  *
  194.  *    Procedure to map from Unix setreuid system call to Sprite Proc_SetIDs.
  195.  *
  196.  * Results:
  197.  *    UNIX_ERROR is returned upon error, with the actual error code
  198.  *    stored in errno.  Upon success, UNIX_SUCCESS is returned.
  199.  *
  200.  * Side effects:
  201.  *    The real and effective user ID's of the process are modified as
  202.  *    specified, if the user is privileged to do so.
  203.  *
  204.  *----------------------------------------------------------------------
  205.  */
  206.  
  207. int
  208. setreuid(ruid, euid)
  209.     int    ruid, euid;
  210. {
  211.     ReturnStatus status;    /* result returned by Proc_SetIDs */
  212.  
  213.     if (ruid == -1) {
  214.     ruid = PROC_NO_ID;
  215.     }
  216.     if (euid == -1) {
  217.     euid = PROC_NO_ID;
  218.     }
  219.     status = Proc_SetIDs(ruid, euid);
  220.     if (status != SUCCESS) {
  221.     errno = Compat_MapCode(status);
  222.     return(UNIX_ERROR);
  223.     } else {
  224.     return(UNIX_SUCCESS);
  225.     }
  226. }
  227.  
  228. /*
  229.  *----------------------------------------------------------------------
  230.  *
  231.  * setregid --
  232.  *
  233.  *    Procedure to map from Unix setregid system call to Sprite Proc_SetIDs.
  234.  *    Sprite doesn't have the notion of real and effective groud IDs;
  235.  *    instead, both gid arguments become the set of Sprite group IDs for
  236.  *    current process.
  237.  *
  238.  * Results:
  239.  *      UNIX_SUCCESS    - the call was successful.
  240.  *      UNIX_ERROR      - the call was not successful.
  241.  *                        The actual error code stored in errno.
  242.  *
  243.  * Side effects:
  244.  *    The previous group IDs are deleted.
  245.  *
  246.  *----------------------------------------------------------------------
  247.  */
  248.  
  249. int
  250. setregid(rgid, egid)
  251.     int    rgid, egid;
  252. {
  253.     ReturnStatus status = SUCCESS;
  254.     int array[2];
  255.     int num = 0;
  256.  
  257.     /*
  258.      * Make the rgid and egid the group IDs for the process. If a gid is
  259.      * -1, it is ignored.
  260.      */
  261.  
  262.     if (rgid != -1) {
  263.     array[0] = rgid;
  264.     num = 1;
  265.     if (egid != rgid && egid != -1) {
  266.         array[1] = egid;
  267.         num++;
  268.     }
  269.     } else if (egid != -1) {
  270.     array[0] = egid;
  271.     num++;
  272.     }
  273.     if (num > 0) {
  274.     status = Proc_SetGroupIDs(num, array);
  275.     }
  276.  
  277.     if (status != SUCCESS) {
  278.     errno = Compat_MapCode(status);
  279.     return(UNIX_ERROR);
  280.     } else {
  281.     return(UNIX_SUCCESS);
  282.     }
  283. }
  284. @
  285.  
  286.  
  287. 1.1
  288. log
  289. @Initial revision
  290. @
  291. text
  292. @d13 1
  293. a13 1
  294. static char rcsid[] = "$Header: id.c,v 1.4 87/07/20 11:13:32 andrew Exp $ SPRITE (Berkeley)";
  295. d16 2
  296. a17 3
  297. #include "sprite.h"
  298. #include "proc.h"
  299. #include "io.h"
  300. @
  301.